﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using GestionePolveriLib.Facades;
using GestionePolveriLib.BL;
using System.Transactions;
using GestionePolveri2.Editors;
using GestionePolveriLib.Utilities;
using System.Globalization;
using GestionePolveriLib.Facades.Extensions;

namespace GestionePolveri2.Editors
{
    public partial class CaricoDettaglio : DettaglioControlBase
    {
        private int m_causale;
        private Double quant_old;
        private string dynNoteTextBox_old;
        private int idPolvere_old = 0;
        private string m_numfatt = null;
        private long m_idlotto = 0;
        private Double m_giacenzaFinale;
        private Double m_giacenza_iniziale;
        private string numddt_old;
        private DateTime m_dataRegistrazione = DateTime.Now;
        private Boolean onlynote = false;
        private bool m_checkLenght = true;
        private LottoNCInfo m_lottoNCInfo = null;

        public DateTime DataRegistrazione
        {
            get { return m_dataRegistrazione; }
            set { m_dataRegistrazione = value; }
        }

        public CaricoDettaglio()
        {
            InitializeComponent();
        }

        #region Load Section...
        private void LoadPolveri()
        {
            FilterComboBoxHelper.SetupPolveriComboBoxCS(this.dynCmbPolveri);

            //PolvereFacade pf = new PolvereFacade();
            //pf.RunAsync<List<Polvere>>(() => pf.GetPolveriForCSMinimal(), (result) =>
            //{
            //    if (result != null)
            //    {
            //        List<Polvere> m_data = new List<Polvere>();
            //        m_data.Add(new Polvere() { CodicePolvere = "Seleziona una polvere", ID = -1 });
            //        m_data.AddRange((List<Polvere>)result);

            //        this.dynCmbPolveri.DisplayMember = "CodicePolvere";
            //        this.dynCmbPolveri.ValueMember = "ID";
            //        this.dynCmbPolveri.DataSource = m_data;
            //    }
            //});
        }

        private void LoadColori()
        {
            ComposizioneColoreFacadeExt pf = new ComposizioneColoreFacadeExt();

            if (this.dynCmbPolveri.SelectedValue != null)
            {
                List<Colore> colori = pf.GetColoriAssociati(((Polvere)this.dynCmbPolveri.SelectedValue).ID);

                if (colori != null)
                {
                    this.dynLVColoriAbbinati.Items.Clear();

                    foreach (Colore c in colori)
                    {
                        ListViewItem item = new ListViewItem(c.CodiceColore);
                        dynLVColoriAbbinati.View = View.Details;
                        item.Name = c.CodiceColore;
                        item.Tag = c;
                        ListViewItem.ListViewSubItem sItem1 = new ListViewItem.ListViewSubItem(item, c.Applicazione);
                        item.SubItems.Add(sItem1);

                        ListViewItem.ListViewSubItem sItem = new ListViewItem.ListViewSubItem(item, c.FamigliaDescrizione);
                        item.SubItems.Add(sItem);

                        //dynLVColoriAbbinati.Columns.Add("Applicazione",-2, HorizontalAlignment.Left);

                        this.dynLVColoriAbbinati.Items.Add(item);
                    }
                    //this.dynLVColoriAbbinati.ItemChecked += new ItemCheckedEventHandler(dynLVColoriAbbinati_ItemChecked);
                }
            }
        }

        private void LoadScatole()
        {
            ScatoleFacade pf = new ScatoleFacade();

            pf.LoadScatoleAsync((result) =>
            {
                List<Scatola> m_data = new List<Scatola>();
                m_data.Add(new Scatola() { Formato = "Seleziona un formato", ID = -1 });
                m_data.AddRange((List<Scatola>)result);

                this.dyncmbScatole.DisplayMember = "Formato";
                this.dyncmbScatole.ValueMember = "ID";

                this.dyncmbScatole.DataSource = m_data;

                if (this.Movimento != null)
                {
                    this.dynnumScatoleTextBox.TextChanged -= new EventHandler(dynnumScatoleTextBox_TextChanged);
                    this.dynntxtWeight.TextChanged -= new EventHandler(dynntxtWeight_TextChanged);
                    this.dyncmbScatole.SelectedIndexChanged -= new EventHandler(dyncmbScatole_SelectedIndexChanged);

                    this.SelectComboItem(this.dyncmbScatole, this.Movimento.Formato);

                    this.dynnumScatoleTextBox.Text = this.Movimento.NumScatole.ToString("F");
                    this.dynntxtWeight.Text = (this.Movimento.NumScatole * ((Scatola)(dyncmbScatole.SelectedValue)).Pezzatura).ToString("F");

                    this.dyncmbScatole.SelectedIndexChanged += new EventHandler(dyncmbScatole_SelectedIndexChanged);
                    this.dynntxtWeight.TextChanged += new EventHandler(dynntxtWeight_TextChanged);
                    this.dynnumScatoleTextBox.TextChanged += new EventHandler(dynnumScatoleTextBox_TextChanged);
                }

                this.dyncmbScatole.SelectedIndexChanged += new EventHandler(dyncmbScatole_SelectedIndexChanged);
            });
        }
        #endregion

        #region Event Handlers...
        private void btnLottoNC_Click(object sender, EventArgs e)
        {
            LottoNCEditor lnce = new LottoNCEditor();
            
            if (this.Movimento != null)
            {
                LottoNCFacade lncf = new LottoNCFacade();
                this.Movimento.LottoNCInfo = lncf.GetLottoNC(this.Movimento.IDLotto);
                lnce.LottoNCInfo = this.Movimento.LottoNCInfo;
            }

            if (lnce.ShowDialog() == DialogResult.OK)
            {
                //lnce.Save();

                m_lottoNCInfo = lnce.LottoNCInfo;
                this.chkLottoNC.Checked = m_lottoNCInfo.IsLottoNC.GetValueOrDefault();
            }
        }

        void btnCreatePolvereXXXX_Click(object sender, EventArgs e)
        {
            NewPolvereXXXXDialog npxd = new NewPolvereXXXXDialog();

            Polvere m_polvere = (Polvere)this.dynCmbPolveri.SelectedValue;
            if (m_polvere != null)
            {
                System.Security.Principal.IPrincipal m_operatore = System.Threading.Thread.CurrentPrincipal;
                if (m_operatore.IsInRole("Amministrazione"))
                {
                    if ((m_polvere.ID != -1) && (m_polvere.IsCodiceCustom))
                    {
                        npxd.Polvere = m_polvere;
                    }
                }

                if (npxd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    LoadPolveri();

                    int index = this.dynCmbPolveri.FindStringExact(npxd.CodicePolvere, 0);
                    this.dynCmbPolveri.SelectedIndex = index;

                    FrameworkLib.Utilities.Singleton<GestionePolveriLib.Cache.LookUpData>.Instance.Refresh();
                }

                //this.btnCreatePolvereXXXX.Click -= new EventHandler(btnCreatePolvereXXXX_Click);
            }
            else
            {
                MessageBox.Show("Selezionare correttamente una polvere.", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void dynCmbPolveri_SelectedIndexChanged(object sender, EventArgs e)
        {
            LoadColori();

            PolvereFacade pf = new PolvereFacade();

            Polvere m_polvere = (Polvere)this.dynCmbPolveri.SelectedValue;

            //btnCreatePolvereXXXX.Enabled = false;
            if (m_polvere != null)
            {
                if (m_polvere.ID != -1)
                {
                    this.dynDescrizionePolvere.Text = string.Format("Polvere: {0}", m_polvere.Descrizione);
                    //this.dynFornitoreDescrizione.Text = string.Format("Fornitore: {0}", m_polvere.Fornitore.Descrizione);
                    this.dynFornitoreDescrizione.Text = string.Format("Fornitore: {0}", m_polvere.FornitoreDescrizione);
                    this.dynNotePolvere.Text = string.Format("Note: {0}", m_polvere.Note);

                    // Se la polvere selezionata è una polvere XXXX, abilita il tasto per la sua eventuale modifica...
                    if (m_polvere.IsCodiceCustom)
                    {
                        btnCreatePolvereXXXX.Enabled = true;
                    }
                }
            }
        }

        private void dynLottoTextBox_TextChanged(object sender, EventArgs e)
        {
            CalcolaDataScadenza();
        }

        private void dyncmbScatole_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (dynnumScatoleTextBox.Enabled && dynntxtWeight.Enabled)
            {
                dynnumScatoleTextBox.Enabled = true;
                dynntxtWeight.Enabled = false;

                dynnumScatoleTextBox.Text = "0";
            }
            else
            {
                dynnumScatoleTextBox.Enabled = true;
                dynntxtWeight.Enabled = true;
            }

            //this.dynntxtWeight.TextChanged -= new EventHandler(dynntxtWeight_TextChanged);
            //this.dynnumScatoleTextBox.TextChanged -= new EventHandler(dynnumScatoleTextBox_TextChanged);
            //CalcolaQuantita();
            //this.dynnumScatoleTextBox.TextChanged += new EventHandler(dynnumScatoleTextBox_TextChanged);
            //this.dynntxtWeight.TextChanged += new EventHandler(dynntxtWeight_TextChanged);
        }

        void dynnumScatoleTextBox_KeyDown(object sender, KeyEventArgs e)
        {
            if ((e.KeyCode == Keys.Delete) || (e.KeyCode == Keys.Back))
            {
                m_checkLenght = false;
            }
            else
            {
                m_checkLenght = true;
            }
        }

        void dynnumScatoleTextBox_TextChanged(object sender, EventArgs e)
        {
            //CalcolaQuantita();
            if (string.IsNullOrWhiteSpace(this.dynnumScatoleTextBox.Text))
            {
                this.dynntxtWeight.Text = string.Empty;
            }
            else
            {
                if ((this.dynnumScatoleTextBox.Text.Length == 2) && (m_checkLenght))
                {
                    this.dynnumScatoleTextBox.Text += "0";
                }

                CalcolaPeso();

                if (!dynntxtWeight.Enabled)
                {
                    dynntxtWeight.Enabled = true;
                }
            }

        }

        void dynntxtWeight_TextChanged(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(this.dynntxtWeight.Text))
            {
                this.dynnumScatoleTextBox.Text = string.Empty;
            }
            else
            {
                if (this.dyncmbScatole.SelectedIndex != -1)
                {
                    CalcolaQuantita();
                }
            }
        }

        private void dyndataDdtDateTimePicker_ValueChanged(object sender, EventArgs e)
        {
            CalcolaDataScadenza();
        }
        #endregion


        public override void SetMovimento()
        {
            ////this.dynnumDdtTextBox.Text = this.dataGridView1.Rows[0].Cells[1].ToString();
            this.dynnumDdtTextBox.Text = this.Movimento.NumDdt;
            this.dyndataDdtDateTimePicker.Value = this.Movimento.DataDdt;
            this.dyndataMovimentoDateTimePicker.Value = this.Movimento.DataMovimento;
            this.dynDataScadenzaTimePicker1.Value = this.Movimento.DataScadenzaLotto;
            this.dynnumScatoleTextBox.Text = this.Movimento.NumScatole.ToString();
            this.dynQuantita.Text = this.Movimento.Quantita.ToString("0.00");
            this.dynntxtWeight.Text = this.Movimento.Quantita.ToString("0.00");

            this.SelectComboItem(this.dynCmbPolveri, this.Movimento.CodicePolvere);

            this.dynLottoTextBox.Text = this.Movimento.CodiceLotto;
            m_idlotto = this.Movimento.IDLotto;

            this.SelectComboItem(this.dyncmbScatole, this.Movimento.Formato);

            this.dynNoteTextBox.Text = this.Movimento.Note;
            idPolvere_old = this.Movimento.IDPolvere;
            quant_old = this.Movimento.Quantita;
            dynNoteTextBox_old = this.Movimento.Note;
            m_numfatt = this.Movimento.NumFattura;
            m_giacenzaFinale = this.Movimento.GiacenzaFinale;
            m_giacenza_iniziale = this.Movimento.GiacenzaIniziale;
            numddt_old = this.Movimento.NumDdt;

            this.dynnumScatoleTextBox.Enabled = true;
            this.dynntxtWeight.Enabled = true;

            if (this.Movimento.LottoNCInfo != null)
            {
                this.chkLottoNC.Checked = this.Movimento.LottoNCInfo.IsLottoNC.GetValueOrDefault();
            }
        }

        //protected void SelectComboItem(ComboBox comboBox, string item)
        //{
        //    comboBox.SelectedIndex = comboBox.FindString(item);
        //}
        #region Private Methods...
        private decimal CalcolaNumScatole()
        {
            NumberStyles style = NumberStyles.Number | NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
            CultureInfo culture = CultureInfo.CreateSpecificCulture("it-IT");

            decimal num;
            decimal.TryParse(dynnumScatoleTextBox.Text, style, culture, out num);

            return num;
        }

        private decimal CalcolaQuantita()
        {
            this.dynnumScatoleTextBox.TextChanged -= new EventHandler(dynnumScatoleTextBox_TextChanged);

            decimal quant = 0;
            decimal peso = 0;

            NumberStyles style;
            CultureInfo culture;

            style = NumberStyles.Number | NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
            culture = CultureInfo.CreateSpecificCulture("it-IT");

            if (!(this.dyncmbScatole.SelectedIndex == -1) && (decimal.TryParse(dynntxtWeight.Text, style, culture, out peso)))
            {
                if (((Scatola)(dyncmbScatole.SelectedValue)).Pezzatura != 0)
                {
                    quant = peso / ((Scatola)(dyncmbScatole.SelectedValue)).Pezzatura;

                    string p = quant.ToString("F");
                    this.dynQuantita.Text = p;

                    //if (p.EndsWith("0"))
                    //{
                    //    p = p.Substring(0, p.Length - 1);
                    //}

                    this.dynnumScatoleTextBox.Text = p; // quant.ToString(); //.ToString("F");
                }
            }

            this.dynnumScatoleTextBox.TextChanged += new EventHandler(dynnumScatoleTextBox_TextChanged);

            return quant;
        }

        private decimal CalcolaPeso()
        {
            this.dynntxtWeight.TextChanged -= new EventHandler(dynntxtWeight_TextChanged);

            decimal quant = 0;
            decimal num = 0;

            NumberStyles style;
            CultureInfo culture;

            style = NumberStyles.Number | NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
            culture = CultureInfo.CreateSpecificCulture("it-IT");

           
            if (!(this.dyncmbScatole.SelectedIndex == -1) && (decimal.TryParse(dynnumScatoleTextBox.Text, style, culture, out num)))
            {
                quant = num * ((Scatola)(dyncmbScatole.SelectedValue)).Pezzatura;
                dynQuantita.Text = quant.ToString();

                //this.dynntxtWeight.DoFormat = false;
                this.dynntxtWeight.Text = quant.ToString("F");
                //this.dynntxtWeight.DoFormat = true;
            }

            this.dynntxtWeight.TextChanged += new EventHandler(dynntxtWeight_TextChanged);

            return quant;
        }

        private void CalcolaDataScadenza()
        {
            if (!(string.IsNullOrEmpty(dynLottoTextBox.Text)))
            {
                LottoFacade lot = new LottoFacade();
                Lotto lotto = lot.GetLotto(dynLottoTextBox.Text);
                if (lotto == null)
                    this.dynDataScadenzaTimePicker1.Value = this.dyndataDdtDateTimePicker.Value.AddMonths(6);
                else
                    this.dynDataScadenzaTimePicker1.Value = lotto.DataScadenzaLotto;
            }
        }

        private double AssegnaPrezzoDefault()
        {
            double prezzodefault = 0;
            LottoFacade lot = new LottoFacade();
            Lotto lotto = lot.GetUltimoCaricoLotto(this.dynLottoTextBox.Text);
            if (lotto == null)
            {
                lotto = lot.GetUltimoCaricoPolvere(((Polvere)this.dynCmbPolveri.SelectedValue).ID);
                if (lotto == null)
                    prezzodefault = 0;
                else
                    prezzodefault = lotto.PrezzoUnitario;
            }
            else
                prezzodefault = lotto.PrezzoUnitario;

            return prezzodefault;
        }
        #endregion

        #region Public Methods...
        public override bool Validate(string op)
        {
            bool retValue = true;
            decimal num = 0;
            double quant = 0;
            onlynote = false;

            if (dynCmbPolveri.SelectedIndex == 0)
            {
                retValue = false;
                MessageBox.Show("Selezionare un codice polvere");
                return retValue;
            }

            if (string.IsNullOrEmpty(this.dynnumDdtTextBox.Text))
            {
                retValue = false;
                MessageBox.Show("Inserire un numero DDT");
                return retValue;
            }

            if (string.IsNullOrEmpty(dynLottoTextBox.Text))
            {
                retValue = false;
                MessageBox.Show("Inserire un numero Lotto");
                return retValue;
            }

            if (dyncmbScatole.SelectedIndex == 0)
            {
                retValue = false;
                MessageBox.Show("Selezionare un formato per le scatole");
                return retValue;
            }

            if (op == "A")
            {
                LottoFacade lf = new LottoFacade();
                Lotto lo = new Lotto();
                lo = lf.GetDDT(dynnumDdtTextBox.Text, ((Polvere)dynCmbPolveri.SelectedValue).Fornitore.ID, dyndataDdtDateTimePicker.Value.Date);
                if (lo != null)
                {
                    if (System.Windows.Forms.MessageBox.Show("Attenzione!...Numero DDT con data " + lo.DataDdt + " e fornitore " + lo.Fornitore + " già presente.Continuare?",
                                       "Conferma Aggiornamento", MessageBoxButtons.YesNo) == DialogResult.No)
                    {
                        retValue = false;
                        //MessageBox.Show("Numero DDT gia' presente con data " + lo.DataDdt);
                        return retValue;
                    }
                }
            }


            if (op == "M" && dynnumDdtTextBox.Text != numddt_old)
            //if (op == "M" )
            {
                LottoFacade lf = new LottoFacade();
                Lotto lo = new Lotto();
                lo = lf.GetDDT(dynnumDdtTextBox.Text, ((Polvere)dynCmbPolveri.SelectedValue).Fornitore.ID, dyndataDdtDateTimePicker.Value.Date);
                if (lo != null)
                {
                    if (System.Windows.Forms.MessageBox.Show("Attenzione!...Numero DDT con data " + lo.DataDdt + " e fornitore " + lo.Fornitore + " già presente.Continuare?",
                                       "Conferma Aggiornamento", MessageBoxButtons.YesNo) == DialogResult.No)
                    {
                        retValue = false;
                        //MessageBox.Show("Numero DDT gia' presente con data " + lo.DataDdt);
                        return retValue;
                    }
                }
            }

            if (!(string.IsNullOrEmpty(m_numfatt)))
            //if (!(m_numfatt == null))
            {
                if (dynNoteTextBox.Text != dynNoteTextBox_old)
                {
                    if (System.Windows.Forms.MessageBox.Show("Il DDT associato al movimento di carico è gia' fatturato. La modifica sarà effettuata solo per campo 'NOTE' . Continuare?",
                                       "Conferma Aggiornamento", MessageBoxButtons.YesNo) == DialogResult.No)
                    {
                        retValue = false;
                        return retValue;
                    }
                    onlynote = true;
                }
                else
                {
                    retValue = false;
                    MessageBox.Show("Non è possibile modificare/Cancellare il movimento di carico in quanto il DDT associato è gia' fatturato. E' possibile modificare solo il campo NOTE");
                    return retValue;
                }
            }

            if (m_giacenza_iniziale != m_giacenzaFinale)
            {
                if (op == "M")
                {
                    //if (double.TryParse(dynQuantita.Text, out quant))
                    if (double.TryParse(dynntxtWeight.Text, out quant))
                    {
                        MovimentiFacade mf = new MovimentiFacade();
                        if (Math.Round(quant, 2) < Math.Round(mf.GetScarichiQuant(m_idlotto), 2))
                        {
                            retValue = false;
                            MessageBox.Show("La quantita' indicata è inferiore a quella gia' scaricata");
                            return retValue;
                        }
                    }
                    if (idPolvere_old != ((Polvere)dynCmbPolveri.SelectedValue).ID)
                    {
                        if (System.Windows.Forms.MessageBox.Show("Attenzione!...Il codice polvere sarà aggiornato anche su tutti i movimenti di scarico collegati. Continuare?",
                                       "Conferma Aggiornamento", MessageBoxButtons.YesNo) == DialogResult.No)
                        {
                            retValue = false;
                            return retValue;
                        }
                    }
                }
                if (op == "D")
                {
                    retValue = false;
                    MessageBox.Show("Non è possibile cancellare il movimento di carico in quanto il Lotto è gia' stato movimentato");
                    return retValue;
                }
            }

            if (op != "D")
            {
                if (!(decimal.TryParse(dynnumScatoleTextBox.Text, out num)))
                {
                    retValue = false;
                    MessageBox.Show("Valore non numerico per numero scatole");
                    return retValue;
                }
                else
                {
                    if (num <= 0)
                    {
                        retValue = false;
                        MessageBox.Show("Numero scatole non valido. Inserire un valore maggiore di zero");
                        return retValue;
                    }
                    else
                    {
                        //CalcolaQuantita();
                        //CalcolaPeso();

                        //dynQuantita.Text = (num * ((Scatola)(dyncmbScatole.SelectedValue)).Pezzatura).ToString();

                        //this.dynntxtWeight.Text = (num * ((Scatola)(dyncmbScatole.SelectedValue)).Pezzatura).ToString();
                    }
                }
            }

            this.IsClosable = retValue;

            return retValue;
        }

        public override void InitializeControl()
        {
            CausaliMagazzinoFacade cmf = new CausaliMagazzinoFacade();
            m_causale = cmf.GetCausaleByCod("C").ID;
            btnCreatePolvereXXXX.Enabled = false;

            LoadScatole();

            LoadPolveri();

            LoadColori();

            this.btnCreatePolvereXXXX.Click += new EventHandler(btnCreatePolvereXXXX_Click);
            this.dynCmbPolveri.SelectedIndexChanged += new EventHandler(dynCmbPolveri_SelectedIndexChanged);
            //this.dyncmbScatole.SelectedIndexChanged += new EventHandler(dyncmbScatole_SelectedIndexChanged);
            this.dynLottoTextBox.TextChanged += new EventHandler(dynLottoTextBox_TextChanged);
            this.dyndataDdtDateTimePicker.ValueChanged += new EventHandler(dyndataDdtDateTimePicker_ValueChanged);

            this.dynnumScatoleTextBox.KeyDown += new KeyEventHandler(dynnumScatoleTextBox_KeyDown);
            this.dynnumScatoleTextBox.TextChanged += new EventHandler(dynnumScatoleTextBox_TextChanged);
            this.dynntxtWeight.TextChanged += new EventHandler(dynntxtWeight_TextChanged);

            //
            dynnumScatoleTextBox.Enabled = false;
            dynntxtWeight.Enabled = false;

            if (this.Movimento != null)
            {
                SetMovimento();
            }

            SecurityChecks();

            OnLoadData(EventArgs.Empty);
        }

        private void SecurityChecks()
        {
            System.Security.Principal.IPrincipal m_operatore = System.Threading.Thread.CurrentPrincipal;

            this.chkLottoNC.Visible = false;
            if((m_operatore.IsInRole("Amministrazione")) || (m_operatore.IsInRole("Verniciatura")))
            {
                //this.chkLottoNC.Visible = true;
            }
        }

        public override bool Add()
        {
            bool retValue = false;

            if (Validate("A"))
            {
                PolvereFacade polF = new PolvereFacade();
                OrdersDatesFacade odf = new OrdersDatesFacade();

                using (TransactionScope transaction = new TransactionScope())
                {
                    // inserisco prima il record relativo al lotto
                    Lotto lot = new Lotto();
                    lot.CodLotto = dynLottoTextBox.Text;
                    lot.NumDdt = dynnumDdtTextBox.Text;
                    lot.DataDdt = dyndataDdtDateTimePicker.Value;
                    lot.DataScadenzaLotto = dynDataScadenzaTimePicker1.Value;
                    double quant = 0;

                    //if (double.TryParse(dynQuantita.Text, out quant))
                    if (double.TryParse(dynntxtWeight.Text, out quant))
                    {
                        lot.Giacenza = quant;

                        lot.PrezzoUnitario = AssegnaPrezzoDefault();
                        //lot.Valore = prezzodefault * quant;
                    }

                    lot.IDPolvere = ((Polvere)dynCmbPolveri.SelectedValue).ID;

                    LottoFacade impl = new LottoFacade();
                    long idl = impl.AddLotto(lot);

                    // inserisco il record relativo al movimento
                    Movimento imp = new Movimento();
                    imp.IDCausale = m_causale;
                    imp.DataMovimento = dyndataMovimentoDateTimePicker.Value;
                    imp.DataRegistrazione = m_dataRegistrazione;

                    imp.IDPolvere = ((Polvere)dynCmbPolveri.SelectedValue).ID;
                    imp.IDFormato = ((Scatola)dyncmbScatole.SelectedValue).ID;
                    imp.Formato = ((Scatola)dyncmbScatole.SelectedValue).Formato;

                    /**/
                    imp.NumScatole = (double)CalcolaNumScatole();
                    imp.Quantita = (double)CalcolaPeso();

                    imp.Note = this.dynNoteTextBox.Text;
                    imp.IDOperatore = this.Principal.Operatore.ID;
                    imp.IDLotto = idl;

                    imp.Note = this.dynNoteTextBox.Text;

                    MovimentiFacade impf = new MovimentiFacade();
                    impf.AddMovimento(imp);

                    // gestione dello stato di movimentazione del lotto...
                    impl.UpdateStatoMovimentazione(idl, false);

                    if (m_lottoNCInfo != null)
                    {
                        if ((imp.IDLotto != 0) && (imp.IDLotto != -1))
                        {
                            m_lottoNCInfo.IDLotto = imp.IDLotto;

                            LottoNCFacade lncf = new LottoNCFacade();
                            lncf.AddOrModify(m_lottoNCInfo);
                        }
                    }

                    // gestione dello stato di riordino...
                    Polvere m_polvere = polF.GetScortaMinimaInfo(imp.IDPolvere);
                    if (m_polvere.QuantitaDisponibile > m_polvere.ScortaMinima)
                    {
                        odf.SetOrderCloseDate(imp.IDPolvere);
                    }

                    //// aggiungo allo storico...
                    //imp.Giacenza = lot.Giacenza;
                    //imp.PrezzoUnitario = lot.PrezzoUnitario;
                    //impf.AddToStoricoMovimenti(imp);

                    transaction.Complete();

                    MessageBox.Show("Inserimento Effettuato con successo !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    retValue = true;
                }

                btnCreatePolvereXXXX.Enabled = false;

                OnLoadData(EventArgs.Empty);
            }

            return retValue;
        }

        public override bool Modify()
        {
            bool retValue = false;

            if (Validate("M"))
            {
                using (System.Transactions.TransactionScope transaction = new System.Transactions.TransactionScope())
                {
                    Movimento imp = new Movimento();
                    MovimentiFacade impf = new MovimentiFacade();

                    //imp.RowVersion = this.Movimento.RowVersion;

                    //if (dynNoteTextBox.Text != dynNoteTextBox_old)
                    if (onlynote)
                    {
                        imp.IDMovimento = this.Movimento.IDMovimento;
                        imp.Note = this.dynNoteTextBox.Text;
                        impf.ModifyNoteMovimento(imp);
                    }
                    else
                    {
                        imp.IDMovimento = this.Movimento.IDMovimento;
                        imp.IDCausale = m_causale;
                        imp.DataMovimento = dyndataMovimentoDateTimePicker.Value;
                        imp.DataRegistrazione = m_dataRegistrazione;
                        imp.NumDdt = dynnumDdtTextBox.Text;
                        imp.DataDdt = dyndataDdtDateTimePicker.Value;
                        imp.IDPolvere = ((Polvere)dynCmbPolveri.SelectedValue).ID;
                        imp.IDFormato = ((Scatola)dyncmbScatole.SelectedValue).ID;

                        imp.NumScatole = (double)CalcolaNumScatole();
                        imp.Quantita = (double)CalcolaPeso();

                        //double num;
                        //if (double.TryParse(dynnumScatoleTextBox.Text, out num))
                        //    imp.NumScatole = num;

                        imp.Note = this.dynNoteTextBox.Text;
                        imp.IDOperatore = this.Principal.Operatore.ID;
                        imp.IDLotto = this.Movimento.IDLotto;

                        imp.Note = this.dynNoteTextBox.Text;

                        double qscar = impf.GetScarichiQuant(this.Movimento.IDLotto);

                        //MovimentiFacade impf = new MovimentiFacade();
                        //double quant = 0;
                        ////if (double.TryParse(dynQuantita.Text, out quant))
                        //if (double.TryParse(dynntxtWeight.Text, out quant))
                        //{
                        //    imp.Quantita = quant;
                        //    //imp.Giacenza = quant - qscar;
                        //    //imp.Valore = imp.Giacenza * AssegnaPrezzoDefault(); ;
                        //}

                        impf.ModifyMovimento(imp);

                        //Modifico il lotto
                        Lotto lot = new Lotto();
                        lot.IDLotto = this.Movimento.IDLotto;
                        lot.CodLotto = dynLottoTextBox.Text;
                        lot.NumDdt = dynnumDdtTextBox.Text;
                        lot.DataDdt = dyndataDdtDateTimePicker.Value;
                        lot.DataScadenzaLotto = dynDataScadenzaTimePicker1.Value;

                        lot.GiacenzaIniziale = imp.Quantita;

                        lot.PrezzoUnitario = AssegnaPrezzoDefault();

                        lot.IDPolvere = ((Polvere)dynCmbPolveri.SelectedValue).ID;

                        LottoFacade lotf = new LottoFacade();

                        lotf.ModifyLotto(lot, qscar);

                        if (m_lottoNCInfo != null)
                        {
                            if ((imp.IDLotto != 0) && (imp.IDLotto != -1))
                            {
                                m_lottoNCInfo.IDLotto = imp.IDLotto;

                                LottoNCFacade lncf = new LottoNCFacade();
                                lncf.AddOrModify(m_lottoNCInfo);
                            }
                        }

                        //in questo punto la giacenza progressiva sui movimenti non è stata aggiornata 
                        //se dovesse servire bisognerebbe aggiornarla opportunamente 
                        if (qscar > 0 && idPolvere_old != imp.IDPolvere)
                            impf.AggScarichi(lot.IDLotto, imp.IDPolvere);
                    }

                    transaction.Complete();
                    MessageBox.Show("Modifica Effettuata con successo !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    retValue = true;
                }

                btnCreatePolvereXXXX.Enabled = false;

                OnLoadData(EventArgs.Empty);
            }

            return retValue;
        }

        public override bool Delete()
        {
            bool retValue = false;

            if (Validate("D"))
            {
                Movimento imp = new Movimento();
                imp.IDMovimento = this.Movimento.IDMovimento;

                MovimentiFacade impf = new MovimentiFacade();
                imp = impf.GetMovimento(this.Movimento.IDMovimento);

                using (System.Transactions.TransactionScope transaction = new System.Transactions.TransactionScope())
                {
                    LottoFacade lot = new LottoFacade();
                    if (impf.DeleteFisicaMovimento(imp))
                    {
                        if (lot.DeleteLotto(imp.IDLotto))
                        {
                            transaction.Complete();

                            MessageBox.Show("Cancellazione Effettuata con successo !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Information);

                            retValue = true;
                        }
                    }
                    else
                    {
                        MessageBox.Show("Cancellazione Fallita !", "Gestione Polveri", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                }

                OnLoadData(EventArgs.Empty);
            }

            return retValue;
        }

        public override void ClearControls()
        {
            this.dynLVColoriAbbinati.Items.Clear();
            m_numfatt = null;
            m_giacenzaFinale = 0;
            m_giacenza_iniziale = 0;
            this.dyndataMovimentoDateTimePicker.Value = DateTime.Now;
            this.dyndataDdtDateTimePicker.Value = DateTime.Now;
            btnCreatePolvereXXXX.Enabled = false;
        }
        #endregion

        public void EnableXXXXButton()
        {
            this.btnCreatePolvereXXXX.Enabled = true;
        }

        public void RefreshMovimento()
        {
            MovimentiFacade mf = new MovimentiFacade();
            Movimento m = mf.GetMovimento(this.Movimento.IDMovimento);
            this.Movimento = m;

            this.SetMovimento();
        }
    }
}
